package com.sun.temp.controller;

import com.sun.temp.bean.ExcelResultBean;
import com.sun.temp.bean.QaRpaCureInspBean;
import com.sun.temp.common.result.Result;
import com.sun.temp.mapper.mapper2.ExcelResultDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

/**
 * <p>
 * $ {description}
 * </p>
 *
 * @author: Mr.Wang
 * @create: 2025-09-25 20:07
 **/
@Slf4j
@RestController
@RequestMapping("/excel")
public class ExcelDataController {


    @Resource
    private ExcelResultDao excelResultDao;

    /**
     * 查找CSV文件中特定时间点（3、6、9...300秒）的数据
     * @return 符合条件的数据行列表
     */
    @GetMapping("/findDataByTimePoints")
    public Result<List<String>> findDataByTimePoints(@RequestParam String grade) {
//        String filePath = "D:\\curelasto\\tmp\\test.CSV";
        String filePath = "D:\\USERS\\01001433\\DESKTOP\\"+grade+".CSV";
        List<String> resultList = new ArrayList<>();

        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            int rowNumber = 1;

            // 跳过前两行数据
            while (rowNumber <= 2 && (line = reader.readLine()) != null) {
                System.out.println("跳过第" + rowNumber + "行: " + line);
                rowNumber++;
            }

            // 遍历剩余的数据行
            while ((line = reader.readLine()) != null) {
                if (line.trim().isEmpty()) {
                    rowNumber++;
                    continue; // 跳过空行
                }

                // 优先尝试用逗号分割
                String[] parts = line.trim().split(",");

                // 如果逗号分割后元素数量较少，尝试用空格分割
                if (parts.length < 2) {
                    parts = Pattern.compile("\\s+").split(line.trim());
                }

                // 检查是否有足够的数据列
                if (parts.length >= 2) { // 至少需要有两列数据（第一列是时间秒）
                    try {
                        // 解析第一列（时间秒）
                        String timeStr = parts[0].trim();
                        double time = Double.parseDouble(timeStr);

                        // 检查时间是否是3的倍数，且在3到300之间
                        if (time >= 3 && time <= 300 && Math.abs(time % 3) < 0.001) {
                            // 处理行数据，去除数值中的前导零
                            String processedRow = processRowWithLeadingZeros(line);
                            resultList.add(processedRow);
//                            System.out.println("找到符合条件的时间点: " + time + "秒 (行号: " + rowNumber + ")");
                        }
                    } catch (NumberFormatException ignored) {
                        System.out.println("警告: 第" + rowNumber + "行第一列不是有效的时间值");
                    }
                }
                rowNumber++;
            }

            return Result.success(resultList);
        } catch (IOException e) {
            System.err.println("读取文件时发生错误: " + e.getMessage());
            return Result.failed("读取文件时发生错误: " + e.getMessage());
        }
    }

    /**
     * 处理行数据，去除数值中的前导零
     * @param row 原始行数据
     * @return 处理后的行数据
     */
    private static String processRowWithLeadingZeros(String row) {
        // 首先尝试用逗号分割
        String[] parts = row.trim().split(",");

        // 如果逗号分割后的元素较少，尝试用空格分割
        if (parts.length < 2) {
            parts = Pattern.compile("\\s+").split(row.trim());
        }

        // 处理每个部分，去除数值的前导零
        StringBuilder processedRow = new StringBuilder();
        for (int i = 0; i < parts.length; i++) {
            String part = parts[i].trim();

            // 对于第一列（温度列），保持原样
            if (i == 0) {
                processedRow.append(part);
            } else {
                // 对于其他列，尝试去除前导零
                processedRow.append(removeLeadingZeros(part));
            }

            // 添加分隔符（如果不是最后一个元素）
            if (i < parts.length - 1) {
                // 使用逗号作为分隔符，保持与原始格式一致
                processedRow.append(",");
            }
        }

        return processedRow.toString();
    }

    /**
     * 去除数字字符串中的前导零
     * @param value 数字字符串
     * @return 去除前导零后的字符串
     */
    private static String removeLeadingZeros(String value) {
        // 检查是否是纯数字
        if (value.matches("\\d+")) {
            // 对于纯数字，去除前导零
            return value.replaceFirst("^0+", "");
        } else if (value.matches("\\d+\\.\\d+")) {
            // 对于小数，只去除整数部分的前导零
            String[] parts = value.split("\\.");
            if (parts.length == 2) {
                String integerPart = parts[0].replaceFirst("^0+", "");
                // 如果整数部分全是零，保留一个零
                if (integerPart.isEmpty()) {
                    integerPart = "0";
                }
                return integerPart + "." + parts[1];
            }
        }
        // 非数字格式，保持原样
        return value;
    }

    /**
     * 保存实验数据3、6、9、12....300
     * @param list
     * @return
     */
    @PostMapping("/saveExcelData")
    public Result saveExcelData(@RequestBody List<ExcelResultBean> list) {
        list.stream().forEach(bean -> bean.setCREATEDATE(new Date()));
        excelResultDao.insertBatch(list);
        return Result.success();
    }

    // 获取所有数据
    @PostMapping("/getAllExcelData")
    public Result getAllExcelData() {
        excelResultDao.getAllExcelData();
        return Result.success();
    }

    // 删除数据
    @GetMapping("/deleteExcelData")
    public Result deleteExcelData(@RequestParam String batch) {
        return Result.success(excelResultDao.deleteExcelData(batch));
    }

}
